home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / js / jsinterp.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  14KB  |  323 lines
  1. /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is Mozilla Communicator client code, released
  17.  * March 31, 1998.
  18.  *
  19.  * The Initial Developer of the Original Code is
  20.  * Netscape Communications Corporation.
  21.  * Portions created by the Initial Developer are Copyright (C) 1998
  22.  * the Initial Developer. All Rights Reserved.
  23.  *
  24.  * Contributor(s):
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28.  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. #ifndef jsinterp_h___
  41. #define jsinterp_h___
  42. /*
  43.  * JS interpreter interface.
  44.  */
  45. #include "jsprvtd.h"
  46. #include "jspubtd.h"
  47.  
  48. JS_BEGIN_EXTERN_C
  49.  
  50. /*
  51.  * JS stack frame, allocated on the C stack.
  52.  */
  53. struct JSStackFrame {
  54.     JSObject        *callobj;       /* lazily created Call object */
  55.     JSObject        *argsobj;       /* lazily created arguments object */
  56.     JSObject        *varobj;        /* variables object, where vars go */
  57.     JSScript        *script;        /* script being interpreted */
  58.     JSFunction      *fun;           /* function being called or null */
  59.     JSObject        *thisp;         /* "this" pointer if in method */
  60.     uintN           argc;           /* actual argument count */
  61.     jsval           *argv;          /* base of argument stack slots */
  62.     jsval           rval;           /* function return value */
  63.     uintN           nvars;          /* local variable count */
  64.     jsval           *vars;          /* base of variable stack slots */
  65.     JSStackFrame    *down;          /* previous frame */
  66.     void            *annotation;    /* used by Java security */
  67.     JSObject        *scopeChain;    /* scope chain */
  68.     jsbytecode      *pc;            /* program counter */
  69.     jsval           *sp;            /* stack pointer */
  70.     jsval           *spbase;        /* operand stack base */
  71.     uintN           sharpDepth;     /* array/object initializer depth */
  72.     JSObject        *sharpArray;    /* scope for #n= initializer vars */
  73.     uint32          flags;          /* frame flags -- see below */
  74.     JSStackFrame    *dormantNext;   /* next dormant frame chain */
  75.     JSObject        *xmlNamespace;  /* null or default xml namespace in E4X */
  76. };
  77.  
  78. typedef struct JSInlineFrame {
  79.     JSStackFrame    frame;          /* base struct */
  80.     void            *mark;          /* mark before inline frame */
  81.     void            *hookData;      /* debugger call hook data */
  82.     JSVersion       callerVersion;  /* dynamic version of calling script */
  83. } JSInlineFrame;
  84.  
  85. /* JS stack frame flags. */
  86. #define JSFRAME_CONSTRUCTING  0x01  /* frame is for a constructor invocation */
  87. #define JSFRAME_INTERNAL      0x02  /* internal call, not invoked by a script */
  88. #define JSFRAME_SKIP_CALLER   0x04  /* skip one link when evaluating f.caller
  89.                                        for this invocation of f */
  90. #define JSFRAME_ASSIGNING     0x08  /* a complex (not simplex JOF_ASSIGNING) op
  91.                                        is currently assigning to a property */
  92. #define JSFRAME_DEBUGGER      0x10  /* frame for JS_EvaluateInStackFrame */
  93. #define JSFRAME_EVAL          0x20  /* frame for obj_eval */
  94. #define JSFRAME_SPECIAL       0x30  /* special evaluation frame flags */
  95. #define JSFRAME_COMPILING     0x40  /* frame is being used by compiler */
  96. #define JSFRAME_COMPILE_N_GO  0x80  /* compiler-and-go mode, can optimize name
  97.                                        references based on scope chain */
  98. #define JSFRAME_SCRIPT_OBJECT 0x100 /* compiling source for a Script object */
  99.  
  100. #define JSFRAME_OVERRIDE_SHIFT 24   /* override bit-set params; see jsfun.c */
  101. #define JSFRAME_OVERRIDE_BITS  8
  102.  
  103. /*
  104.  * Property cache for quickened get/set property opcodes.
  105.  */
  106. #define PROPERTY_CACHE_LOG2     10
  107. #define PROPERTY_CACHE_SIZE     JS_BIT(PROPERTY_CACHE_LOG2)
  108. #define PROPERTY_CACHE_MASK     JS_BITMASK(PROPERTY_CACHE_LOG2)
  109.  
  110. #define PROPERTY_CACHE_HASH(obj, id) \
  111.     ((((jsuword)(obj) >> JSVAL_TAGBITS) ^ (jsuword)(id)) & PROPERTY_CACHE_MASK)
  112.  
  113. #ifdef JS_THREADSAFE
  114.  
  115. #if HAVE_ATOMIC_DWORD_ACCESS
  116.  
  117. #define PCE_LOAD(cache, pce, entry)     JS_ATOMIC_DWORD_LOAD(pce, entry)
  118. #define PCE_STORE(cache, pce, entry)    JS_ATOMIC_DWORD_STORE(pce, entry)
  119.  
  120. #else  /* !HAVE_ATOMIC_DWORD_ACCESS */
  121.  
  122. #define JS_PROPERTY_CACHE_METERING      1
  123.  
  124. #define PCE_LOAD(cache, pce, entry)                                           \
  125.     JS_BEGIN_MACRO                                                            \
  126.         uint32 prefills_;                                                     \
  127.         uint32 fills_ = (cache)->fills;                                       \
  128.         do {                                                                  \
  129.             /* Load until cache->fills is stable (see FILL macro below). */   \
  130.             prefills_ = fills_;                                               \
  131.             (entry) = *(pce);                                                 \
  132.         } while ((fills_ = (cache)->fills) != prefills_);                     \
  133.     JS_END_MACRO
  134.  
  135. #define PCE_STORE(cache, pce, entry)                                          \
  136.     JS_BEGIN_MACRO                                                            \
  137.         do {                                                                  \
  138.             /* Store until no racing collider stores half or all of pce. */   \
  139.             *(pce) = (entry);                                                 \
  140.         } while (PCE_OBJECT(*pce) != PCE_OBJECT(entry) ||                     \
  141.                  PCE_PROPERTY(*pce) != PCE_PROPERTY(entry));                  \
  142.     JS_END_MACRO
  143.  
  144. #endif /* !HAVE_ATOMIC_DWORD_ACCESS */
  145.  
  146. #else  /* !JS_THREADSAFE */
  147.  
  148. #define PCE_LOAD(cache, pce, entry)     ((entry) = *(pce))
  149. #define PCE_STORE(cache, pce, entry)    (*(pce) = (entry))
  150.  
  151. #endif /* !JS_THREADSAFE */
  152.  
  153. typedef union JSPropertyCacheEntry {
  154.     struct {
  155.         JSObject        *object;        /* weak link to object */
  156.         JSScopeProperty *property;      /* weak link to property */
  157.     } s;
  158. #ifdef HAVE_ATOMIC_DWORD_ACCESS
  159.     prdword align;
  160. #endif
  161. } JSPropertyCacheEntry;
  162.  
  163. /* These may be called in lvalue or rvalue position. */
  164. #define PCE_OBJECT(entry)       ((entry).s.object)
  165. #define PCE_PROPERTY(entry)     ((entry).s.property)
  166.  
  167. typedef struct JSPropertyCache {
  168.     JSPropertyCacheEntry table[PROPERTY_CACHE_SIZE];
  169.     JSBool               empty;
  170.     JSBool               disabled;
  171. #ifdef JS_PROPERTY_CACHE_METERING
  172.     uint32               fills;
  173.     uint32               recycles;
  174.     uint32               tests;
  175.     uint32               misses;
  176.     uint32               flushes;
  177. # define PCMETER(x)      x
  178. #else
  179. # define PCMETER(x)      /* nothing */
  180. #endif
  181. } JSPropertyCache;
  182.  
  183. #define PROPERTY_CACHE_FILL(cache, obj, id, sprop)                            \
  184.     JS_BEGIN_MACRO                                                            \
  185.         JSPropertyCache *cache_ = (cache);                                    \
  186.         if (!cache_->disabled) {                                              \
  187.             uintN hashIndex_ = (uintN) PROPERTY_CACHE_HASH(obj, id);          \
  188.             JSPropertyCacheEntry *pce_ = &cache_->table[hashIndex_];          \
  189.             JSPropertyCacheEntry entry_;                                      \
  190.             JSScopeProperty *pce_sprop_;                                      \
  191.             PCE_LOAD(cache_, pce_, entry_);                                   \
  192.             pce_sprop_ = PCE_PROPERTY(entry_);                                \
  193.             PCMETER(if (pce_sprop_ && pce_sprop_ != sprop)                    \
  194.                         cache_->recycles++);                                  \
  195.             PCE_OBJECT(entry_) = obj;                                         \
  196.             PCE_PROPERTY(entry_) = sprop;                                     \
  197.             cache_->empty = JS_FALSE;                                         \
  198.             PCMETER(cache_->fills++);                                         \
  199.             PCE_STORE(cache_, pce_, entry_);                                  \
  200.         }                                                                     \
  201.     JS_END_MACRO
  202.  
  203. #define PROPERTY_CACHE_TEST(cache, obj, id, sprop)                            \
  204.     JS_BEGIN_MACRO                                                            \
  205.         uintN hashIndex_ = (uintN) PROPERTY_CACHE_HASH(obj, id);              \
  206.         JSPropertyCache *cache_ = (cache);                                    \
  207.         JSPropertyCacheEntry *pce_ = &cache_->table[hashIndex_];              \
  208.         JSPropertyCacheEntry entry_;                                          \
  209.         JSScopeProperty *pce_sprop_;                                          \
  210.         PCE_LOAD(cache_, pce_, entry_);                                       \
  211.         pce_sprop_ = PCE_PROPERTY(entry_);                                    \
  212.         PCMETER(cache_->tests++);                                             \
  213.         if (pce_sprop_ &&                                                     \
  214.             PCE_OBJECT(entry_) == obj &&                                      \
  215.             pce_sprop_->id == id) {                                           \
  216.             sprop = pce_sprop_;                                               \
  217.         } else {                                                              \
  218.             PCMETER(cache_->misses++);                                        \
  219.             sprop = NULL;                                                     \
  220.         }                                                                     \
  221.     JS_END_MACRO
  222.  
  223. extern void
  224. js_FlushPropertyCache(JSContext *cx);
  225.  
  226. extern void
  227. js_DisablePropertyCache(JSContext *cx);
  228.  
  229. extern void
  230. js_EnablePropertyCache(JSContext *cx);
  231.  
  232. extern JS_FRIEND_API(jsval *)
  233. js_AllocStack(JSContext *cx, uintN nslots, void **markp);
  234.  
  235. extern JS_FRIEND_API(void)
  236. js_FreeStack(JSContext *cx, void *mark);
  237.  
  238. extern JSBool
  239. js_GetArgument(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
  240.  
  241. extern JSBool
  242. js_SetArgument(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
  243.  
  244. extern JSBool
  245. js_GetLocalVariable(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
  246.  
  247. extern JSBool
  248. js_SetLocalVariable(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
  249.  
  250. #ifdef DUMP_CALL_TABLE
  251. # define JSOPTION_LOGCALL_TOSOURCE JS_BIT(15)
  252.  
  253. extern JSHashTable  *js_CallTable;
  254. extern size_t       js_LogCallToSourceLimit;
  255.  
  256. extern void         js_DumpCallTable(JSContext *cx);
  257. #endif
  258.  
  259. /*
  260.  * Compute the 'this' parameter and store it in frame as frame.thisp.
  261.  * Activation objects ("Call" objects not created with "new Call()", i.e.,
  262.  * "Call" objects that have private data) may not be referred to by 'this',
  263.  * as dictated by ECMA.
  264.  *
  265.  * N.B.: fp->argv must be set, fp->argv[-1] the nominal 'this' paramter as
  266.  * a jsval, and fp->argv[-2] must be the callee object reference, usually a
  267.  * function object.  Also, fp->flags must contain JSFRAME_CONSTRUCTING if we
  268.  * are preparing for a constructor call.
  269.  */
  270. extern JSBool
  271. js_ComputeThis(JSContext *cx, JSObject *thisp, JSStackFrame *fp);
  272.  
  273. /*
  274.  * NB: js_Invoke requires that cx is currently running JS (i.e., that cx->fp
  275.  * is non-null), and that the callee, |this| parameter, and actual arguments
  276.  * are already pushed on the stack under cx->fp->sp.
  277.  */
  278. extern JS_FRIEND_API(JSBool)
  279. js_Invoke(JSContext *cx, uintN argc, uintN flags);
  280.  
  281. /*
  282.  * Consolidated js_Invoke flags simply rename the low JSFRAME_* flags.
  283.  */
  284. #define JSINVOKE_CONSTRUCT      JSFRAME_CONSTRUCTING
  285. #define JSINVOKE_INTERNAL       JSFRAME_INTERNAL
  286. #define JSINVOKE_SKIP_CALLER    JSFRAME_SKIP_CALLER
  287.  
  288. /*
  289.  * "Internal" calls may come from C or C++ code using a JSContext on which no
  290.  * JS is running (!cx->fp), so they may need to push a dummy JSStackFrame.
  291.  */
  292. #define js_InternalCall(cx,obj,fval,argc,argv,rval)                           \
  293.     js_InternalInvoke(cx, obj, fval, 0, argc, argv, rval)
  294.  
  295. #define js_InternalConstruct(cx,obj,fval,argc,argv,rval)                      \
  296.     js_InternalInvoke(cx, obj, fval, JSINVOKE_CONSTRUCT, argc, argv, rval)
  297.  
  298. extern JSBool
  299. js_InternalInvoke(JSContext *cx, JSObject *obj, jsval fval, uintN flags,
  300.                   uintN argc, jsval *argv, jsval *rval);
  301.  
  302. extern JSBool
  303. js_InternalGetOrSet(JSContext *cx, JSObject *obj, jsid id, jsval fval,
  304.                     JSAccessMode mode, uintN argc, jsval *argv, jsval *rval);
  305.  
  306. extern JSBool
  307. js_Execute(JSContext *cx, JSObject *chain, JSScript *script,
  308.            JSStackFrame *down, uintN flags, jsval *result);
  309.  
  310. extern JSBool
  311. js_CheckRedeclaration(JSContext *cx, JSObject *obj, jsid id, uintN attrs,
  312.                       JSObject **objp, JSProperty **propp);
  313.  
  314. extern JSBool
  315. js_StrictlyEqual(jsval lval, jsval rval);
  316.  
  317. extern JSBool
  318. js_Interpret(JSContext *cx, jsbytecode *pc, jsval *result);
  319.  
  320. JS_END_EXTERN_C
  321.  
  322. #endif /* jsinterp_h___ */
  323.